#include<iostream>
using namespace std;
// int main(){
//     cout << "Hello, world\n";
//     int i = 10;
//     double b = 10.3;
//     cout << i << " " << b << endl;//cout相当于printf，但是它可以自动识别变量类型，不用占位符

// }

// void Func(int a = 0){//-----缺省参数，如果没传实参，就用这个缺省参数
//     cout << a << endl;
// }
// int main(){
//     Func(11);
//     return 0;
// }

//--------函数的重载，就是函数名相同，但是参数的（个数 or 类型 or 类型顺序）不同
// int add(int a, int b){
//     return a + b;
// }
// double add(double a, double b){
//     return a + b;
// }
// double add(double b, double a){
//     return a + b;
// }-------------这样就不是重载，因为与上面的函数参数类型和个数和位置相同
// int main(){
//     cout << add(10,20) << endl;
//     cout << add(10.2,20.2) << endl;

//     return 0;
// }

//单单返回值不同不能构成重载


//---------------------引用-----------------------
#include<iostream>
using namespace std;
int main1(){
    int a = 1;
    int& b = a;
    int& c = b;//引用就是别名，别名对原变量的改变相当于直接对原变量进行改变
    c = 2;
    int& d = c = 1;
    cout << c << " " << d <<endl;

    return 0;
}
int main2(){
    int a = 1;
    int& b = a;
    int c = 2;
    b = c; //------------只是将c的值赋给a的别名b，而不是使别名b变成c的别名
    cout << a << endl;
    cout << &a << endl;
    cout << &c << endl;
    return 0;
}
int main3(){
    int a = 2;
    int &b = a;
    int c = 3;
    int &d = c;
    b = d;//-------------相当于将c赋值给a
    cout << b << " " << d << endl;

    return 0;
}
int main4(){ 
    // const int a = 1;//-----------只读
    // int& b = a;//No//------------可读可写

    const int a = 1;
    const int& b = a;//YES

    // int a = 1;
    // const int& b = a;//YES

    //给变量取别名时，范围可以缩小，但不能扩大
    return 0;
}
int main5(){
    int i = 1;  
    double b = i;
    const double & c = i;//-----const 关键字的使用允许在不同类型之间创建引用
                        //但前提是这种引用不会允许通过该引用修改原始数据
    double& db = b;
    cout << db << endl;
    cout << c << endl;

    return 0;
}

//------权限的放大缩小规则只适用于指针和引用，而不适用于普通的类型转换

int Add1(int a, int b){
    int c = a + b;
    return c;
}

int main(){
    int ret = Add1(1, 2);
    cout << "Add1(1, 2) is :" << ret << endl;
    return 0;
}